﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Reflection;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;

using Outlook = Microsoft.Office.Interop.Outlook;

using System.Security;
using System.Collections.ObjectModel;
using System.Management.Automation;
using System.Management.Automation.Runspaces;
using System.Security.AccessControl;
using System.Security.Principal;

namespace MigrationTool
{
    /// <summary>
    /// メールデータ移行ツールメインフォームクラス
    /// </summary>
    public partial class MigrationToolForm : Form
    {
        #region USER32のインポート
        [DllImport("USER32.DLL", CharSet = CharSet.Auto)]
        private static extern int ShowWindow(System.IntPtr hWnd, int nCmdShow);

        [DllImport("USER32.DLL", CharSet = CharSet.Auto)]
        private static extern bool SetForegroundWindow(System.IntPtr hWnd);

        [DllImport("user32.dll")]
        private static extern bool IsZoomed(IntPtr hWnd);
        #endregion

        #region 定数
        private const int TIME_CHECK = 500;
        private const int TIMEOUT_LIMIT = 20;
        private const string DELIMSTR = ",";

        #endregion

        #region インスタンス
        Process prcOutLook = new Process();
        ProcessStartInfo info = new ProcessStartInfo();
        CommonModule clsMod = new CommonModule();

        Outlook._Application olApp1;
        Outlook._NameSpace olNS1;
        Outlook.MAPIFolder oFolder1;
        Outlook.SyncObject olSyncObj1;
        #endregion

        #region 変数
        private int intOutLookId = 0;
        private int DownloadTime = 0;
        private int ExportTime = 0;
        private int AccountCount = 0;
        private int OutLookTime = 0;
        private bool bolMigrationMailBoxExport = true;
        private bool bolMigrationMailBoxImport = true;
        #endregion

        #region コンストラクタ
        /// <summary>
        /// コンストラクタ
        /// </summary>
        public MigrationToolForm()
        {
            InitializeComponent();
        }
        #endregion

        #region イベント
        /// <summary>
        /// フォームロード
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MigrationToolForm_Load(object sender, EventArgs e)
        {
            //アプリケーション設定ファイルから登録値を取得し、コントロールにセットする。
            txtImapServerName.Text = Properties.Settings.Default.Imap_ImapServerName;
            numImapServerPort.Value = Properties.Settings.Default.Imap_ImapPort;
            txtEx2013ServerName.Text = Properties.Settings.Default.Imap_Ex2013ServerName;
            txtEx2013Domain.Text = Properties.Settings.Default.Imap_Ex2013DomainName;
            txtEx2013User.Text = Properties.Settings.Default.Imap_Ex2013UserName;
            txtImapTargetFilePath.Text = Properties.Settings.Default.Imap_TargetFilePath;
            txtImapPstFilePath.Text = Properties.Settings.Default.Imap_PstFilePath;
            txt2013PstFilePath.Text = Properties.Settings.Default.Imap_PstFilePath2013;
            txtPublicFolder2003.Text = Properties.Settings.Default.Exchange_PublicFolderName2003;
            txtPublicFolder2013.Text = Properties.Settings.Default.Exchange_PublicFolderName2013;
            txtEx2003ServerFullName.Text = Properties.Settings.Default.Exchange2003_ServerFullName;
            txtEx2003Domain.Text = Properties.Settings.Default.Exchange2003_DomainName;
            txtEx2003AdminUser.Text = Properties.Settings.Default.Exchange2003_AdminUserName;
            txtPublicPstFilePath2003.Text = Properties.Settings.Default.Imap_PublicPstFilePath2003;
            txtPublicPstFilePath2013.Text = Properties.Settings.Default.Imap_PublicPstFilePath2013;

            //オプション画面設定
            GetOptionFormValue();
        }

        /// <summary>
        /// フォームを閉じる
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MigrationToolForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            //コントロールから入力値を取得し、アプリケーション設定ファイルに保存する。
            Properties.Settings.Default.Imap_ImapServerName = txtImapServerName.Text.Trim();
            Properties.Settings.Default.Imap_ImapPort = numImapServerPort.Value;
            Properties.Settings.Default.Imap_Ex2013ServerName = txtEx2013ServerName.Text.Trim();
            Properties.Settings.Default.Imap_Ex2013DomainName = txtEx2013Domain.Text.Trim();
            Properties.Settings.Default.Imap_Ex2013UserName = txtEx2013User.Text.Trim();
            Properties.Settings.Default.Imap_TargetFilePath = txtImapTargetFilePath.Text.Trim();
            Properties.Settings.Default.Imap_PstFilePath = txtImapPstFilePath.Text.Trim();
            Properties.Settings.Default.Imap_PstFilePath2013 = txt2013PstFilePath.Text.Trim();
            Properties.Settings.Default.Exchange_PublicFolderName2003 = txtPublicFolder2003.Text.Trim();
            Properties.Settings.Default.Exchange_PublicFolderName2013 = txtPublicFolder2013.Text.Trim();
            Properties.Settings.Default.Exchange2003_ServerFullName = txtEx2003ServerFullName.Text.Trim();
            Properties.Settings.Default.Exchange2003_DomainName = txtEx2003Domain.Text.Trim();
            Properties.Settings.Default.Exchange2003_AdminUserName = txtEx2003AdminUser.Text.Trim();
            Properties.Settings.Default.Imap_PublicPstFilePath2003 = txtPublicPstFilePath2003.Text.Trim();
            Properties.Settings.Default.Imap_PublicPstFilePath2013 = txtPublicPstFilePath2013.Text.Trim();
            Properties.Settings.Default.Save();
            //リスナーの解放
            FileLogTrace.ListenerRemove();
        }

        /// <summary>
        /// メニューバーの「オプション」クリック
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void menuToolOption_Click(object sender, EventArgs e)
        {
            using (OptionForm option = new OptionForm())
            {
                option.ShowDialog();
            }
        }

        /// <summary>
        /// メールエクスポート用実行ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExecuteImap_Click(object sender, EventArgs e)
        {
            //画面ログの初期化
            txtImapLog.Text = string.Empty;
            clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "IMAP　メールデータ　エクスポート"));
            //ツールオプションの設定値取得
            GetOptionFormValue();
            //正常出力用フラグの初期化
            bolMigrationMailBoxExport = true;
            //コントロールの非活性化
            SwitchExecButton(false);
            //OutLookを終了する
            ExitProcessOutLook(0);
            //入力チェック
            if (!CheckInputTextEmptyMailBoxExport())
            {
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //パスの存在チェック
            if (!CheckTextFilePathMailBoxExport())
            {
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //実行確認
            if (MessageBox.Show(MessageConst.MSG_QUESTION_MAIL_EXPORT, string.Empty, MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.Cancel)
            {
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_CANCEL, "IMAP　メールデータ　エクスポート"));
                //コントロールの活性化
                SwitchExecButton( true);
                return;
            }
            //IMAPサーバーの設定
            ImapServerInformation imapInfo = new ImapServerInformation();
            imapInfo.ServerName = txtImapServerName.Text.Trim();        //サーバー名
            imapInfo.PortNumber = numImapServerPort.Value;              //ポート
            imapInfo.UserPassword = txtImapPassword.Text.Trim();        //管理者のパスワード
            //エクスポート設定
            string targetFile = txtImapTargetFilePath.Text.Trim();          //対象ユーザー定義ファイル
            string pstFolder = txtImapPstFilePath.Text.Trim().TrimEnd('\\');//pstファイル出力先フォルダ
            try
            {
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "ユーザーリスト作成処理"));
                //ユーザーリストの生成
                List<string[]> targetUsers = new List<string[]>();
                List<string[]> targetUsersTemp = new List<string[]>();
                try
                {
                    //CSVファイルを読み込む
                    targetUsers = CreateUserList(targetFile,txtImapLog);
                }
                catch
                {
                    MessageBox.Show(MessageConst.MSG_ERROR_INVALIDFILE, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    //コントロールの活性化
                    SwitchExecButton(true);
                    return;
                }
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "ユーザーリスト作成処理"));
                //初期化
                int profileCount = 1;
                int profileCountMod = 0;
                int intUserCount = 0;
                string profileName = string.Empty;
                string prfFilePath = string.Empty;
                //必要プロファイル数の算出
                if (targetUsers.Count > AccountCount)
                {
                    profileCount = targetUsers.Count / AccountCount;
                    profileCountMod = targetUsers.Count % AccountCount;
                    if (profileCountMod != 0)
                    {
                        profileCount++;
                    }
                }
                //処理前にレジストリから前回登録したプロファイルを削除する
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "不要OutLookプロファイル削除処理"));
                for (int i = 0; i < profileCount; i++)
                {
                    profileName = string.Format(ApplicationConst.PROFILE_NAME, (i + 1).ToString());
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_INPROGRESS, profileName + " 削除"));
                    RegistryEdit.DeleteOutlookProfile(profileName);
                }
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "不要OutLookプロファイル削除処理"));
                //前回生成したPSTファイルを削除
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "不要PSTファイル削除処理"));
                for (int i = 1; i <= targetUsers.Count; i++)
                {
                    string strUserName = targetUsers[i - 1][1];
                    //2013側のメールボックス名を取得
                    string strMailBoxName = targetUsers[i - 1][2];
                    if (string.IsNullOrEmpty(strMailBoxName))
                    {
                        strMailBoxName = strUserName;
                    }
                    string filePath = string.Format(ApplicationConst.PATH_PSTFILE, pstFolder, strMailBoxName);
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_INPROGRESS, strMailBoxName + ".pst 削除"));
                    if (File.Exists(filePath))
                    {
                        File.Delete(filePath);
                    }
                }
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "不要PSTファイル削除"));
                //IMAPユーザーの存在チェック
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "対象IMAPユーザー存在確認"));
                for (int i = 1; i <= targetUsers.Count; i++)
                {
                    clsMod.WriteLog(txtImapLog, string.Format(targetUsers[i - 1][1]));
                    Application.DoEvents();
                    if (!ConnectImapServer(imapInfo.ServerName, imapInfo.PortNumber, targetUsers[i - 1][1], imapInfo.UserPassword))
                    {
                        MessageBox.Show(MessageConst.MSG_ERROR_INVALIDPASSWORD, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
                        clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_ERROR, "対象IMAPユーザー存在確認"));
                        //コントロールの活性化
                        SwitchExecButton(true);
                        return;
                    }
                }
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "対象IMAPユーザー存在確認"));
                //出力フォルダーの権限チェック
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "PSTファイル格納フォルダー存在確認"));
                if (!CheckSecurityAndAccessRule(pstFolder))
                {
                    MessageBox.Show(MessageConst.MSG_ERROR_INVALIDAUTHORITY, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_ERROR, "PSTファイル格納フォルダー存在確認"));
                    //コントロールの活性化
                    SwitchExecButton(true);
                    return;
                }
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "PSTファイル格納フォルダー存在確認"));
                //初期化
                int c = 0;
                string profileNameTemp = string.Empty;
                //算出された必要プロファイル数の数だけループ
                for (int i = 0; i < profileCount; i++)
                {
                    //ユーザー数をプロファイルの規定値ごとに振り分けする
                    targetUsersTemp = GetUser(i, targetUsers, profileCountMod, profileCount, ref c);
                    //PRFファイル名の生成
                    profileName = string.Format(ApplicationConst.PROFILE_NAME, (i + 1).ToString());
                    //PRFファイルの生成
                    prfFilePath = CreatePrfFile(ApplicationConst.PATH_PRFFORDER, profileName, targetUsersTemp, imapInfo);
                    //OutLookのプロセス情報
                    info = new ProcessStartInfo();
                    info.FileName = ApplicationConst.APP_OUTLOOK;
                    info.WindowStyle = ProcessWindowStyle.Hidden;
                    //指定プロファイル初回起動時
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "OutLookプロファイル登録処理"));
                    //2つ目以降のプロファイルの起動の場合
                    if (profileNameTemp != string.Empty)
                    {
                        //起動引数を直前のプロファイル名とする
                        info.Arguments = string.Format(ApplicationConst.APP_OPTION, profileNameTemp);
                    }
                    else
                    {
                        //起動引数は指定なし
                    }
                    //レジストリにプロファイル情報を追加
                    RegistryEdit.EditRegistry(prfFilePath);
                    //OutLookを起動する
                    prcOutLook = System.Diagnostics.Process.Start(info);
                    intOutLookId = prcOutLook.Id;
                    SleepApplication(3);

                    //プロセス監視(起動確認用)
                    while (!CheckOutLookProcess())
                    {
                        Thread.Sleep(TIME_CHECK);
                        this.Refresh();
                    }

                    //最大化チェック
                    if (profileNameTemp == string.Empty)
                    {
                        //最大化表示されているかをループで監視
                        while (!OutLookMaximizeWindow() && CheckOutLookProcess())
                        {
                            //OutLookProcessMaximize();
                            Thread.Sleep(TIME_CHECK);
                            this.Refresh();
                            Application.DoEvents();
                        }
                    }

                    //プロセス監視(キャンセルされた場合)
                    if (!CheckOutLookProcess())
                    {
                        clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_CANCEL, "IMAP　メールデータ　エクスポート"));
                        MessageBox.Show(MessageConst.MSG_CANCEL, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
                        //コントロールの活性化
                        SwitchExecButton(true);
                        return;
                    }

                    OutLookProcessHide();
                    Application.DoEvents();
                    SleepApplication(3);
                    //OOMでOutLookを起動
                    olApp1 = new Outlook.Application();
                    olNS1 = olApp1.GetNamespace(ApplicationConst.MAPI);
                    //2つ目以降のプロファイルの起動の場合
                    if (profileNameTemp != string.Empty)
                    {
                        //起動引数を直前のプロファイル名とする
                        olNS1.Logon(profileNameTemp, imapInfo.UserPassword, false, true);
                    }
                    else
                    {
                        //指定なしで起動する
                        olNS1.Logon(Type.Missing, Type.Missing, false, true);
                    }
                    //起動引数を画面で選択されたプロファイル名とする
                    oFolder1 = olNS1.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderCalendar);
                    //初回起動時のみプロファイル名を取得する（移行の処理で使うため）
                    if (profileNameTemp == string.Empty)
                    {
                        profileNameTemp = olNS1.CurrentProfileName;
                    }
                    //同期イベントSyncオブジェクトの生成
                    olSyncObj1 = null;
                    for (int k = 1; k <= olApp1.Session.SyncObjects.Count; k++)
                    {
                        if (k == olApp1.Session.SyncObjects.Count)
                        {
                            olSyncObj1 = olApp1.Session.SyncObjects[k];
                            olSyncObj1.SyncEnd += new Outlook.SyncObjectEvents_SyncEndEventHandler(SyncEndBootEvent);
                        }
                    }
                    //送受信を行い同期イベントを拾う
                    olApp1.Session.SendAndReceive(false);
                    //OutLookが終了するのを待機
                    prcOutLook.WaitForExit();
                    this.Refresh();
                    //レジストリにパスワードを登録する（合わせて暗号化）
                    SetRegistryImapUserPassword(profileName, targetUsersTemp, imapInfo.UserPassword);
                    //OutLookを終了する
                    ExitProcessOutLook(intOutLookId);
                    //プロセス監視
                    while (CheckOutLookProcess() == true)
                    {
                        Thread.Sleep(TIME_CHECK);
                        this.Refresh();
                    }
                    SleepApplication(1);
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "OutLookプロファイル登録処理"));
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "OutLookプロファイル適用処理"));
                    //起動引数を生成された対象のプロファイル名とする
                    info.Arguments = string.Format(ApplicationConst.APP_OPTION_SAFE, profileName);
                    //OutLookを起動する
                    prcOutLook = System.Diagnostics.Process.Start(info);
                    intOutLookId = prcOutLook.Id;

                    //プロセス監視
                    while (!CheckOutLookProcess())
                    {
                        Thread.Sleep(TIME_CHECK);
                        this.Refresh();
                    }
                    int timeWaitSecond = OutLookTime * 2;
                    for (int k = 0; k <= timeWaitSecond; k++)
                    {
                        Thread.Sleep(TIME_CHECK);
                    }
                    OutLookProcessHide();
                    for (int k = 0; k <= timeWaitSecond; k++)
                    {
                        Thread.Sleep(TIME_CHECK);
                    }
                    //SleepApplication(3);
                    Application.DoEvents();
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "PSTファイルサイズ確認"));
                    while (!CheckPstFileSize(targetUsersTemp, profileName, DownloadTime))
                    {
                        Thread.Sleep(TIME_CHECK);
                        Application.DoEvents();
                    }
                    SleepApplication(3);
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "PSTファイルサイズ確認"));
                    //プロセス監視
                    while (CheckOutLookProcess())
                    {
                        OutLookProcessMaximize();
                        SleepApplication(3);
                        prcOutLook.CloseMainWindow();
                        this.Refresh();
                    }
                    SleepApplication(3);
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "OutLookプロファイル適用処理"));
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "PSTファイル作成処理"));
                    //1プロファイルに格納された規定ユーザー数だけループ
                    for (int k = 1; k <= targetUsersTemp.Count; k++)
                    {
                        string strUserName = targetUsersTemp[k - 1][1];
                        clsMod.WriteLog(txtImapLog, strUserName);
                        //2013側のメールボックス名を取得
                        string strMailBoxName = targetUsersTemp[k - 1][2];
                        if (string.IsNullOrEmpty(strMailBoxName))
                        {
                            strMailBoxName = strUserName;
                        }
                        //ユーザーのPSTファイルパスを生成
                        string filePath = string.Format(ApplicationConst.PATH_PSTFILE, pstFolder, strMailBoxName);
                        //OOMでユーザーにログインしのPSTファイル出力を行う
                        using (OutlookOperation outlook = new OutlookOperation(profileName, imapInfo.UserPassword))
                        {
                            Thread.Sleep(3000);
                            clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_INPROGRESS, "PSTファイル作成処理"));
                            intUserCount++;
                            if (!outlook.ExportMailboxPstFile(filePath, strUserName, strMailBoxName, txtImapLog, profileName, ExportTime))
                            {
                                bolMigrationMailBoxExport = false;
                                FileLogTrace.WriteResultLog(string.Format(LogConst.LOG_RESULT_FAILED, strUserName, LogConst.LOG_RESULT_EXPORT), intUserCount);
                            }
                            else
                            {
                                FileLogTrace.WriteResultLog(string.Format(LogConst.LOG_RESULT_SUCCESS, strUserName, LogConst.LOG_RESULT_EXPORT), intUserCount);
                            }
                        }
                    }
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "PSTファイル作成処理"));
                    ExitProcessOutLook(0);
                    //プロセス監視
                    while (CheckOutLookProcess())
                    {
                        Thread.Sleep(TIME_CHECK);
                        this.Refresh();
                    }
                    SleepApplication(1);

                    //ここからはOutLook正常終了のための処理
                    //OOMはプロセスとして終了しきれないので
                    //一度OutLookを起動し、終了させると正常終了扱いとなる
                    RebootOutLookProccess(profileName, imapInfo.UserPassword);

                    //事後処理
                    olApp1 = null;
                    olNS1 = null;
                    oFolder1 = null;
                    olSyncObj1 = null;

                    //OutLookの機能により自動作成されたPSTファイルをすべて削除する
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "使用済みPSTファイル削除処理"));
                    for (int k = 1; k <= targetUsersTemp.Count; k++)
                    {
                        clsMod.WriteLog(txtImapLog, string.Format(targetUsersTemp[k - 1][1]));
                        //OutLookの機能により自動作成されたPSTファイルのファイルパスを生成
                        string strFilePath = string.Format(ApplicationConst.OUTLOOK_DEFAULT_PATH, Environment.UserName.ToString(), Environment.UserDomainName.ToString(), targetUsersTemp[k - 1][1], profileName);
                        if (File.Exists(strFilePath))
                        {
                            //消す
                            File.Delete(strFilePath);
                        }
                    }
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "使用済みPSTファイル削除処理"));
                    //レジストリからプロファイルを削除する
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_START, "使用済みOutLookプロファイル削除処理"));
                    SleepApplication(3);
                    profileName = string.Format(ApplicationConst.PROFILE_NAME, (i + 1).ToString());
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_INPROGRESS, profileName + " 削除"));
                    RegistryEdit.DeleteOutlookProfile(profileName);
                    clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_END, "使用済みOutLookプロファイル削除処理"));
                }
                //終了
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_COMPLETE, "IMAP　メールデータ　エクスポート"));
                string strResultLogPath = string.Format(LogConst.FILE_RESULT_LOG, GetAppPath());
                MessageBox.Show(MessageConst.MSG_FINISH_MAIL_EXPORT + System.Environment.NewLine + strResultLogPath, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
                //正常にエクスポートできなかったものがあった場合
                if (bolMigrationMailBoxExport == false)
                {
                    //アラート
                    string strErrorLogPath = string.Format(LogConst.FILE_ERROR_LOG, GetAppPath());
                    MessageBox.Show(MessageConst.MSG_ERROR_MAIL_EXPORT + System.Environment.NewLine + strErrorLogPath, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                FileLogTrace.WriteErrorLog(DateTime.Now.ToString(LogConst.LOG_TIMEFORMAT) + " " + ex.ToString());
                string strErrorLogPath = string.Format(LogConst.FILE_ERROR_LOG, GetAppPath());
                MessageBox.Show(MessageConst.MSG_FINISH_MAIL_EXPORT_ERROR + System.Environment.NewLine + strErrorLogPath, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            //コントロールの活性化
            SwitchExecButton(true);
        }

        /// <summary>
        /// メールインポート用実行ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExecute2013_Click(object sender, EventArgs e)
        {
            //初期化
            txt2013Log.Text = string.Empty;
            clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_START, "Exchange2013　メールデータ　インポート"));
            //ツールオプションの値取得
            GetOptionFormValue();
            //コントロールの非活性化
            SwitchExecButton(false);
            //正常取込み用フラグの初期化
            bolMigrationMailBoxImport = true;
            //入力チェック
            if (!CheckInputTextEmptyMailBoxImport())
            {
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //パスの存在チェック
            if (!CheckTextFilePathMailBoxImport())
            {
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //実行確認
            if (MessageBox.Show(MessageConst.MSG_QUESTION_MAIL_IMPORT, string.Empty, MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.Cancel)
            {
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_CANCEL, "Exchange2013　メールデータ　インポート"));
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //Exchange2013サーバーの設定
            ExchangeServer2013Information ex2013Info = new ExchangeServer2013Information();
            ex2013Info.ServerName = txtEx2013ServerName.Text.Trim();    //サーバー名
            ex2013Info.DomainName = txtEx2013Domain.Text.Trim();        //ドメイン名
            ex2013Info.UserName = txtEx2013User.Text.Trim();            //管理者のユーザー名
            ex2013Info.UserPassword = txtEx2013Password.Text.Trim();    //管理者のパスワード
            //Exchange2013サーバーの入力情報のチェック
            if (!Check2013Information(ex2013Info))
            {
                MessageBox.Show(MessageConst.MSG_ERROR_INVALIDINFO, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2013ServerName.Focus();
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //インポート設定
            string pstFolder = txt2013PstFilePath.Text.Trim().TrimEnd('\\');//pstファイル出力先フォルダ
            try
            {
                //ユーザーリストの生成
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_START, "対象ユーザーリスト作成処理"));
                List<string[]> targetUsers = new List<string[]>();
                try
                {
                    //CSVファイルを読み込む
                    targetUsers = CreateUserList(pstFolder);
                }
                catch
                {
                    MessageBox.Show(MessageConst.MSG_ERROR_INVALIDFILE, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_END, "対象ユーザーリスト作成処理"));
                    //コントロールの活性化
                    SwitchExecButton(true);
                    return;
                }
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_END, "対象ユーザーリスト作成処理"));
                //出力フォルダーの権限チェック
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_START, "PSTファイル格納フォルダーアクセス権限確認"));
                if (!CheckSecurityAndAccessRule(pstFolder))
                {
                    MessageBox.Show(MessageConst.MSG_ERROR_INVALIDAUTHORITY, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_ERROR, "PSTファイル格納フォルダーアクセス権限確認"));
                    //コントロールの活性化
                    SwitchExecButton(true);
                    return;
                }
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_END, "PSTファイル格納フォルダーアクセス権限確認"));
                //Exchange2013ユーザーの存在チェック
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_START, "対象ユーザーメールボックス存在確認"));
                if (!Check2013UserMailBox(targetUsers, ex2013Info))
                {
                    MessageBox.Show(MessageConst.MSG_ERROR_INVALIDMAILBOX, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_ERROR, "対象ユーザーメールボックス存在確認"));
                    //コントロールの活性化
                    SwitchExecButton(true);
                    return;
                }
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_END, "対象ユーザーメールボックス存在確認"));
                //PSTファイルをExchange2013にインポートする
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_START, "PSTファイルインポート処理"));
                ExecuteRemoteShell(targetUsers, ex2013Info, pstFolder);
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_END, "PSTファイルインポート処理"));
                //終了
                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_COMPLETE, "Exchange2013　メールデータ　インポート"));
                string strResultLogPath = string.Format(LogConst.FILE_RESULT_LOG, GetAppPath());
                MessageBox.Show(MessageConst.MSG_FINISH_MAIL_IMPORT + System.Environment.NewLine + strResultLogPath, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
                //正常にインポートできなかったものがあった場合
                if (bolMigrationMailBoxImport == false)
                {
                    //アラート
                    string strErrorLogPath = string.Format(LogConst.FILE_ERROR_LOG, GetAppPath());
                    MessageBox.Show(MessageConst.MSG_ERROR_MAIL_IMPORT + System.Environment.NewLine + strErrorLogPath, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                FileLogTrace.WriteErrorLog(DateTime.Now.ToString(LogConst.LOG_TIMEFORMAT) + " " + ex.ToString());
                string strErrorLogPath = string.Format(LogConst.FILE_ERROR_LOG, GetAppPath());
                MessageBox.Show(MessageConst.MSG_FINISH_MAIL_IMPORT_ERROR + System.Environment.NewLine + strErrorLogPath, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            //コントロールの活性化
            SwitchExecButton(true);
        }

        /// <summary>
        /// パブリックフォルダーエクスポート用実行ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExecutePf2003_Click(object sender, EventArgs e)
        {
            //初期化
            txtPfLog2003.Text = string.Empty;
            string prfFilePath = string.Empty;
            clsMod.WriteLog(txtPfLog2003, string.Format(LogConst.LOG_START, "Exchange2003　パブリックフォルダー　エクスポート"));
            //ツールオプションの値取得
            GetOptionFormValue();
            //コントロールの非活性化
            SwitchExecButton(false);
            //OutLookを終了する
            ExitProcessOutLook(0);
            //入力チェック
            if (!CheckInputTextEmptyPublicFolderExport())
            {
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //パスの存在チェック
            if (!CheckTextFilePathPublicFolderExport())
            {
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //実行確認
            if (MessageBox.Show(MessageConst.MSG_QUESTION_PF_EXPORT, string.Empty, MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.Cancel)
            {
                clsMod.WriteLog(txtPfLog2003, string.Format(LogConst.LOG_CANCEL, "Exchange2003　パブリックフォルダー　エクスポート"));
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            try
            {
                //Exchange2003サーバー情報の取得
                ExchangeServer2003Information ex2003Info = new ExchangeServer2003Information();
                ex2003Info.ServerName = txtEx2003ServerFullName.Text.Trim();
                ex2003Info.DomainName = txtEx2003Domain.Text.Trim();
                ex2003Info.UserName = txtEx2003AdminUser.Text.Trim();

                //Exchange2003サーバーへの認証情報を登録
                clsMod.WriteLog(txtPfLog2003, string.Format(LogConst.LOG_START, "Exchange2003　サーバー認証登録処理"));
                CreateCredentialInfo(ex2003Info.ServerName, ex2003Info.DomainName, ex2003Info.UserName);
                clsMod.WriteLog(txtPfLog2003, string.Format(LogConst.LOG_END, "Exchange2003　サーバー認証登録処理"));

                //Exchange2003エクスポート設定
                string exportFolderPath = txtPublicPstFilePath2003.Text.Trim();
                string pfFolderName = txtPublicFolder2003.Text.Trim();
                //パブリックフォルダーのPSTファイルパスを生成
                string filePath = string.Format(ApplicationConst.PATH_PSTFILE, exportFolderPath, pfFolderName);
                //すでに出力済みのものがある場合
                if (File.Exists(filePath))
                {
                    //削除
                    File.Delete(filePath);
                }
                SleepApplication(3);
                //Exchange2003のパブリックフォルダーをPSTファイルに出力する。
                clsMod.WriteLog(txtPfLog2003, string.Format(LogConst.LOG_START, "Exchange2003　パブリックフォルダーエクスポート処理"));
                using (OutlookOperation outlook = new OutlookOperation(ApplicationConst.PROFILE_NAME_2003))
                {
                    //パブリックフォルダーをPSTファイルに出力
                    outlook.ExportPublicFolderPstFile(filePath, pfFolderName);
                }
                SleepApplication(3);
                //OutLookを終了する
                ExitProcessOutLook(0);
                SleepApplication(3);

                //ここからはOutLook正常終了のための処理
                //OOMはプロセスとして終了しきれないので
                //一度OutLookを起動し、終了させると正常終了扱いとなる
                RebootOutLookProccess(ApplicationConst.PROFILE_NAME_2003, null);

                olApp1 = null;
                olNS1 = null;
                oFolder1 = null;
                olSyncObj1 = null;
                clsMod.WriteLog(txtPfLog2003, string.Format(LogConst.LOG_END, "Exchange2003　パブリックフォルダーエクスポート処理"));
                //終了
                clsMod.WriteLog(txtPfLog2003, string.Format(LogConst.LOG_COMPLETE, "Exchange2003　パブリックフォルダー　エクスポート"));
                MessageBox.Show(MessageConst.MSG_FINISH_PF_EXPORT, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                FileLogTrace.WriteErrorLog(DateTime.Now.ToString(LogConst.LOG_TIMEFORMAT) + " " + ex.ToString());
                string strErrorLogPath = string.Format(LogConst.FILE_ERROR_LOG, GetAppPath());
                MessageBox.Show(MessageConst.MSG_ERROR_PF_EXPORT + System.Environment.NewLine + strErrorLogPath, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            //コントロールの活性化
            SwitchExecButton(true);
        }

        /// <summary>
        /// パブリックフォルダーインポート用実行ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExecutePf2013_Click(object sender, EventArgs e)
        {
            //初期化
            txtPfLog2013.Text = string.Empty;
            string prfFilePath = string.Empty;
            clsMod.WriteLog(txtPfLog2013, string.Format(LogConst.LOG_START, "Exchange2013　パブリックフォルダー　インポート"));
            //ツールオプションの値取得
            GetOptionFormValue();
            //コントロールの非活性化
            SwitchExecButton(false);
            //OutLookを終了する
            ExitProcessOutLook(0);
            //入力チェック
            if (!CheckInputTextEmptyPublicFolderImport())
            {
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //パスの存在チェック
            if (!CheckTextFilePathPublicFolderImport())
            {
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            //実行確認
            if (MessageBox.Show(MessageConst.MSG_QUESTION_PF_IMPORT, string.Empty, MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.Cancel)
            {
                clsMod.WriteLog(txtPfLog2013, string.Format(LogConst.LOG_CANCEL, "Exchange2013　パブリックフォルダー　インポート"));
                //コントロールの活性化
                SwitchExecButton(true);
                return;
            }
            try
            {
                //インポート設定
                string exportFilePath = txtPublicPstFilePath2013.Text.Trim();
                string pfFolderName = txtPublicFolder2013.Text.Trim();
                //Exchange2013のパブリックフォルダにインポートする
                clsMod.WriteLog(txtPfLog2013, string.Format(LogConst.LOG_START, "Exchange2003　パブリックフォルダーインポート処理"));
                SleepApplication(3);
                using (OutlookOperation outlook = new OutlookOperation(ApplicationConst.PROFILE_NAME_2013))
                {
                    //Exchange2013のパブリックフォルダにインポート
                    outlook.ImportPublicFolderPstFile(exportFilePath, pfFolderName);
                }

                SleepApplication(3);
                //OutLookを終了する
                ExitProcessOutLook(0);
                SleepApplication(3);
                //ここからはOutLook正常終了のための処理
                //OOMはプロセスとして終了しきれないので
                //一度OutLookを起動し、終了させると正常終了扱いとなる
                RebootOutLookProccess(ApplicationConst.PROFILE_NAME_2013, null);

                olApp1 = null;
                olNS1 = null;
                oFolder1 = null;
                olSyncObj1 = null;
                clsMod.WriteLog(txtPfLog2013, string.Format(LogConst.LOG_END, "Exchange2003　パブリックフォルダーインポート処理"));
                //終了
                clsMod.WriteLog(txtPfLog2013, string.Format(LogConst.LOG_COMPLETE, "Exchange2013　パブリックフォルダー　インポート"));
                MessageBox.Show(MessageConst.MSG_FINISH_PF_IMPORT, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                FileLogTrace.WriteErrorLog(DateTime.Now.ToString(LogConst.LOG_TIMEFORMAT) + " " + ex.ToString());
                string strErrorLogPath = string.Format(LogConst.FILE_ERROR_LOG, GetAppPath());
                MessageBox.Show(MessageConst.MSG_ERROR_PF_IMPORT + System.Environment.NewLine + strErrorLogPath, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            //コントロールの活性化
            SwitchExecButton(true);
        }

        /// <summary>
        /// 閉じるボタンクリック（共通）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnClose_Click(object sender, EventArgs e)
        {
            //終了確認
            if (MessageBox.Show(MessageConst.MSG_QUESTION_FINISH, string.Empty, MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
            {
                this.Close();
            }
        }

        /// <summary>
        /// メールエクスポート用ユーザー定義CSVファイル選択用ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnImapSelectFile_Click(object sender, EventArgs e)
        {
            OpenFileDialog selectFileDialog = new OpenFileDialog();
            selectFileDialog.FileName = string.Empty;
            selectFileDialog.Filter = MessageConst.MSG_SELECT_FILTER_CSV;
            selectFileDialog.Title = string.Format(MessageConst.MSG_SELECT_TARGET, MessageConst.MSG_TITLE_FILE);
            selectFileDialog.RestoreDirectory = true;
            //ダイアログを表示する
            if (selectFileDialog.ShowDialog() == DialogResult.OK)
            {
                //選んだパスを画面に取得
                this.txtImapTargetFilePath.Text = selectFileDialog.FileName;
            }
        }

        /// <summary>
        /// メールエクスポート用PSTファイル出力先選択用ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnImapSelectFolder_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog selectDialog = new FolderBrowserDialog();
            selectDialog.Description = string.Format(MessageConst.MSG_SELECT_TARGET, MessageConst.MSG_TITLE_COMMONFOLDER);
            if (!string.IsNullOrEmpty(txtEx2013ServerName.Text))
            {
                selectDialog.SelectedPath = @"\\" + txtEx2013ServerName.Text.Trim() + @"\";
            }
            if (selectDialog.ShowDialog(this) == DialogResult.OK)
            {
                //選んだパスを画面に取得
                this.txtImapPstFilePath.Text = selectDialog.SelectedPath;
            }
        }

        /// <summary>
        /// メールインポート用PSTファイル出力先選択用ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn2013SelectFolder_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog selectDialog = new FolderBrowserDialog();
            selectDialog.Description = string.Format(MessageConst.MSG_SELECT_TARGET, MessageConst.MSG_TITLE_COMMONFOLDER);
            if (!string.IsNullOrEmpty(txtEx2013ServerName.Text))
            {
                selectDialog.SelectedPath = @"\\" + txtEx2013ServerName.Text.Trim() + @"\";
            }
            if (selectDialog.ShowDialog(this) == DialogResult.OK)
            {
                //選んだパスを画面に取得
                this.txt2013PstFilePath.Text = selectDialog.SelectedPath;
            }
        }

        /// <summary>
        /// パブリックフォルダインポート用PSTファイル出力先選択用ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSelectPublicFolder2003_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog selectDialog = new FolderBrowserDialog();
            selectDialog.Description = string.Format(MessageConst.MSG_SELECT_TARGET, MessageConst.MSG_TITLE_FILE);
            if (selectDialog.ShowDialog(this) == DialogResult.OK)
            {
                //選んだパスを画面に取得
                this.txtPublicPstFilePath2003.Text = selectDialog.SelectedPath;
            }
        }

        /// <summary>
        /// パブリックフォルダエクスポート用PSTファイル出力先選択用ボタンクリックイベント
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSelectPublicFolder2013_Click(object sender, EventArgs e)
        {
            OpenFileDialog selectFileDialog = new OpenFileDialog();
            selectFileDialog.FileName = string.Empty;
            selectFileDialog.Filter = MessageConst.MSG_SELECT_FILTER_PST;
            selectFileDialog.Title = string.Format(MessageConst.MSG_SELECT_TARGET, MessageConst.MSG_TITLE_FILE);
            selectFileDialog.RestoreDirectory = true;
            //ダイアログを表示する
            if (selectFileDialog.ShowDialog() == DialogResult.OK)
            {
                //選んだパスを画面に取得
                this.txtPublicPstFilePath2013.Text = selectFileDialog.FileName;
            }
        }
        #endregion

        #region メソッド
        /// <summary>
        /// 実行フォルダパスの取得
        /// </summary>
        /// <returns></returns>
        public string GetAppPath()
        {
            //実行フォルダパスを返却
            return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
        }

        /// <summary>
        /// ＯＯＭが正常に終了するためのOUTLOOK再起動終了処理
        /// </summary>
        /// <param name="strProfileName"></param>
        /// <param name="strPassword"></param>
        private void RebootOutLookProccess(string strProfileName,string strPassword)
        {
            try
            {
                //プロセス情報
                ProcessStartInfo infoReboot = new ProcessStartInfo();
                int intOutLookIdReboot = 0;
                infoReboot.FileName = ApplicationConst.APP_OUTLOOK;
                //起動引数を設定
                infoReboot.Arguments = string.Format(ApplicationConst.APP_OPTION, strProfileName);
                infoReboot.WindowStyle = ProcessWindowStyle.Hidden;
                prcOutLook = System.Diagnostics.Process.Start(infoReboot);
                intOutLookIdReboot = prcOutLook.Id;
                SleepApplication(12);
                //OutLookを終了する
                ExitProcessOutLook(intOutLookIdReboot);
                //OOMで起動
                Outlook._Application olAppReboot = new Outlook.Application();
                Outlook._NameSpace olNSReboot = olAppReboot.GetNamespace(ApplicationConst.MAPI);
                if (string.IsNullOrEmpty(strPassword))
                {
                    olNSReboot.Logon(strProfileName, Type.Missing, false, true);
                }
                else
                {
                    olNSReboot.Logon(strProfileName, strPassword, false, true);
                }
                Outlook.MAPIFolder oFolderReboot = olNSReboot.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderCalendar);
                //同期イベントSyncオブジェクトの生成
                Outlook.SyncObject olSyncObjReboot = null;
                OutLookProcessMaximize();
                for (int k = 1; k <= olAppReboot.Session.SyncObjects.Count; k++)
                {
                    if (k == olAppReboot.Session.SyncObjects.Count)
                    {
                        olSyncObjReboot = olAppReboot.Session.SyncObjects[k];
                        olSyncObjReboot.SyncEnd += new Outlook.SyncObjectEvents_SyncEndEventHandler(SyncEndBootEvent);
                    }
                }
                //送受信を行い同期イベントを拾う
                olAppReboot.Session.SendAndReceive(false);
                //OutLookが終了するまで待機
                prcOutLook.WaitForExit();
                //事後処理
                olAppReboot = null;
                olNSReboot = null;
                oFolderReboot = null;
                olSyncObjReboot = null;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// ユーザー定義ファイルを読み込みリストとして返却する
        /// </summary>
        /// <param name="targetPath"></param>
        /// <returns></returns>
        public List<string[]> CreateUserList(string targetPath,TextBox targetText)
        {
            try
            {
                List<string[]> targetList = new List<string[]>();
                //CSVファイルを読み込む
                StreamReader sr = new StreamReader(targetPath, Encoding.Default);
                string strLine = string.Empty;              //１行分のデータ
                char[] delimiter = DELIMSTR.ToCharArray();  //区切り文字をキャスト
                string[] strData;                           //分解後の文字用変数
                int rowCount = 0;
                while (sr.Peek() >= 0)
                {
                    strLine = sr.ReadLine();
                    strData = strLine.Split(delimiter);
                    //列が3つ無い場合
                    if (strData.Length != 3)
                    {
                        clsMod.WriteLog(targetText, string.Format(LogConst.LOG_ERROR, LogConst.LOG_INVALIDVALUE));
                        throw new Exception();
                    }
                    //列1と列2は必須項目とする
                    if (strData[0].Length == 0 || strData[1].Length == 0)
                    {
                        clsMod.WriteLog(targetText, string.Format(LogConst.LOG_ERROR, LogConst.LOG_INVALIDVALUE));
                        throw new Exception();
                    }
                    //行1はヘッダーなのでそれ以外が対象
                    if (rowCount != 0)
                    {
                        clsMod.WriteLog(targetText, string.Format(LogConst.LOG_ADD, strData[1]));
                        Application.DoEvents();
                        //ユーザーリストに追加
                        targetList.Add(new string[] { strData[0], strData[1], strData[2] });
                    }
                    rowCount++;
                }
                sr.Close();
                return targetList;
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// ユーザー定義ファイルを読み込みリストとして返却する
        /// </summary>
        /// <param name="targetPath"></param>
        /// <returns></returns>
        public List<string[]> CreateUserList(string targetPath)
        {
            try
            {
                List<string[]> targetList = new List<string[]>();
                foreach (string stFilePath in Directory.GetFiles(targetPath, "*.pst"))
                {
                    //ファイル名がEx2013ユーザーエイリアス
                    string strUserName = Path.GetFileNameWithoutExtension(stFilePath);
                    targetList.Add(new string[] { strUserName });
                }
                return targetList;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// プロファイル生成対象のユーザーを作成
        /// </summary>
        /// <param name="index"></param>
        /// <param name="targetUser"></param>
        /// <param name="mod"></param>
        /// <param name="profile"></param>
        /// <param name="count"></param>
        /// <returns></returns>
        private List<string[]> GetUser(int index,List<string[]> targetUser,int mod,int profile,ref int count)
        {
            List<string[]> retUser = new List<string[]>();
            if (targetUser.Count > AccountCount)
            {
                if (mod == 0)
                {
                    for (int j = (index * AccountCount); j < AccountCount * (index + 1); j++)
                    {
                        retUser.Add(targetUser[count]);
                        count++;
                    }
                }
                else
                {
                    if (index == profile - 1)
                    {
                        for (int j = (index * AccountCount); j < (index * AccountCount) + mod; j++)
                        {
                            retUser.Add(targetUser[count]);
                            count++;
                        }
                    }
                    else
                    {
                        for (int j = (index * AccountCount); j < AccountCount * (index + 1); j++)
                        {
                            retUser.Add(targetUser[count]);
                            count++;
                        }
                    }
                }
            }
            else
            {
                for (int j = 0; j < targetUser.Count(); j++)
                {
                    retUser.Add(targetUser[j]);
                }
            }
            return retUser;
        }

        /// <summary>
        /// PRFファイルの出力
        /// </summary>
        /// <param name="prfFolderPath"></param>
        /// <param name="profileName"></param>
        /// <param name="users"></param>
        /// <param name="imapInfomation"></param>
        /// <returns></returns>
        private string CreatePrfFile(string prfFolderPath, string profileName,List<string[]> users, ImapServerInformation imapInfomation)
        {
            try
            {
                string formatSection5 = Properties.Settings.Default.Profile_Format_Section5.Trim();
                string formatSection3 = Properties.Settings.Default.Profile_Format_Section3.Trim();
                //PRF出力先フォルダが存在しない場合はフォルダ作成。
                if (!Directory.Exists(prfFolderPath))
                {
                    Directory.CreateDirectory(prfFolderPath);
                }
                //PRFファイルに書き込む内容を移行対象ユーザー分作成する。
                StringBuilder section5 = new StringBuilder();
                StringBuilder section3 = new StringBuilder();
                for (int i = 1; i <= users.Count; i++)
                {
                    //Section3
                    section3.AppendFormat(formatSection3, i.ToString());
                    section3.Append(Environment.NewLine);
                    //Section5
                    section5.AppendFormat(formatSection5,
                                          i.ToString(),                             //アカウントNo
                                          users[i - 1][1].Trim(),                   //AccountName
                                          imapInfomation.ServerName,                //IMAPServer,SMTPServer
                                          users[i - 1][0].Trim(),                   //IMAPUserName
                                          users[i - 1][0].Trim(),                   //EmailAddress
                                          imapInfomation.PortNumber.ToString());    //IMAPPort
                    section5.Append(Environment.NewLine);
                }
                //PRFファイルのテンプレートを開く。
                string allText = string.Empty;
                using (StreamReader prfReader = new StreamReader(ApplicationConst.TEMPLATE_PRF_IMAP, Encoding.Unicode))
                {
                    //全行を読み込む。
                    allText = prfReader.ReadToEnd();
                }
                //新規作成するPRFファイル名
                string prfFilePath = string.Format(ApplicationConst.PATH_PRFFILE, prfFolderPath.TrimEnd('\\'), profileName);
                //新規ファイルを作成し、内容を書き込む。
                using (StreamWriter prfWriter = new StreamWriter(prfFilePath, false, Encoding.Unicode))
                {
                    //Section1、Section3とSection5を書き込む。
                    prfWriter.Write(allText, profileName, section3, section5);
                }
                return Path.GetFullPath(prfFilePath);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// PRFファイルの出力
        /// </summary>
        /// <param name="prfFolderPath"></param>
        /// <param name="profileName"></param>
        /// <param name="ex2003Information"></param>
        /// <returns></returns>
        private string CreatePrfFile(string prfFolderPath, string profileName, ExchangeServer2003Information ex2003Information)
        {
            try
            {
                string formatSection4 = Properties.Settings.Default.Profile_Format_Section4_2003.Trim();
                //PRF出力先フォルダが存在しない場合はフォルダ作成。
                if (!Directory.Exists(prfFolderPath))
                {
                    Directory.CreateDirectory(prfFolderPath);
                }
                StringBuilder section4 = new StringBuilder();
                //Section4
                section4.AppendFormat(formatSection4,
                                      ex2003Information.UserName,
                                      ex2003Information.ServerName);
                section4.Append(Environment.NewLine);
                //PRFファイルのテンプレートを開く。
                string allText = string.Empty;
                using (StreamReader prfReader = new StreamReader(ApplicationConst.TEMPLATE_PRF_EXCHANGE, Encoding.Unicode))
                {
                    //全行を読み込む。
                    allText = prfReader.ReadToEnd();
                }
                //新規作成するPRFファイル名
                string prfFilePath = string.Format(ApplicationConst.PATH_PRFFILE, prfFolderPath.TrimEnd('\\'), profileName);
                //新規ファイルを作成し、内容を書き込む。
                using (StreamWriter prfWriter = new StreamWriter(prfFilePath, false, Encoding.Unicode))
                {
                    //Section1、Section4を書き込む。
                    prfWriter.Write(allText, profileName, section4);
                }
                return Path.GetFullPath(prfFilePath);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// PRFファイルの出力
        /// </summary>
        /// <param name="prfFolderPath"></param>
        /// <param name="profileName"></param>
        /// <param name="ex2013Information"></param>
        /// <returns></returns>
        private string CreatePrfFile(string prfFolderPath, string profileName, ExchangeServer2013Information ex2013Information)
        {
            try
            {
                string formatSection4 = Properties.Settings.Default.Profile_Format_Section4_2013.Trim();
                //PRF出力先フォルダが存在しない場合はフォルダ作成。
                if (!Directory.Exists(prfFolderPath))
                {
                    Directory.CreateDirectory(prfFolderPath);
                }
                StringBuilder section4 = new StringBuilder();
                //Section4
                section4.AppendFormat(formatSection4,
                                      ex2013Information.UserName,
                                      ex2013Information.ServerName);
                section4.Append(Environment.NewLine);
                //PRFファイルのテンプレートを開く。
                string allText = string.Empty;
                using (StreamReader prfReader = new StreamReader(ApplicationConst.TEMPLATE_PRF_EXCHANGE, Encoding.Unicode))
                {
                    //全行を読み込む。
                    allText = prfReader.ReadToEnd();
                }
                //新規作成するPRFファイル名
                string prfFilePath = string.Format(ApplicationConst.PATH_PRFFILE, prfFolderPath.TrimEnd('\\'), profileName);
                //新規ファイルを作成し、内容を書き込む。
                using (StreamWriter prfWriter = new StreamWriter(prfFilePath, false, Encoding.Unicode))
                {
                    //Section1、Section4を書き込む。
                    prfWriter.Write(allText, profileName, section4);
                }
                return Path.GetFullPath(prfFilePath);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 画面上のボタンの使用切り替えを設定する
        /// </summary>
        /// <param name="btn"></param>
        /// <param name="bolFlg"></param>
        private void SwitchExecButton(bool bolFlg)
        {
            btnExecuteImap.Enabled = bolFlg;
            btnExecute2013.Enabled = bolFlg;
            btnExecutePf2003.Enabled = bolFlg;
            btnExecutePf2013.Enabled = bolFlg;
            btnClose.Enabled = bolFlg;
            btnImapSelectFile.Enabled = bolFlg;

            btnImapSelectFile.Enabled = bolFlg;
            btnImapSelectFolder.Enabled = bolFlg;
            btn2013SelectFolder.Enabled = bolFlg;
            btnSelectPublicFolder2003.Enabled = bolFlg;
            btnSelectPublicFolder2013.Enabled = bolFlg;
        }

        /// <summary>
        /// レジストリにパスワードを登録
        /// </summary>
        /// <param name="profileName"></param>
        /// <param name="users"></param>
        /// <param name="imapUserPassword"></param>
        private void SetRegistryImapUserPassword(string profileName, List<string[]> users, string imapUserPassword)
        {
            try
            {
                //レジストリから、プロファイル配下のアカウント関連キーを取得する
                string targetKeyName = ApplicationConst.REG_KEY_PROFILE + "\\" + profileName + "\\" + ApplicationConst.REG_KEY_ACCOUNT;
                string[] subKeys = RegistryEdit.GetSubKeyNames(targetKeyName);

                foreach (string subKey in subKeys)
                {
                    //レジストリからIMAP Userの値を取得する
                    string accountKey = targetKeyName + "\\" + subKey;
                    object regImapUserName = RegistryEdit.ReadRegistryValue(accountKey, ApplicationConst.REG_IMAPUSER);

                    if (regImapUserName != null)
                    {
                        //取得したIMAP Userを文字列に変換する
                        string regImapUserNameString = RegistryValue.ConvertRegistryBinaryValueToString(regImapUserName);

                        //IMAP Userが指定のユーザーであるか確かめる
                        bool isTarget = false;
                        for (int i = 1; i <= users.Count; i++)
                        {
                            if (users[i - 1][0].ToString() == regImapUserNameString)
                            {
                                isTarget = true;
                                break;
                            }
                        }
                        if (isTarget)
                        {
                            //パスワードを暗号化する
                            byte[] encryptPassword = RegistryValue.EncryptImapPassword(imapUserPassword);
                            //レジストリのIMAP Passwordを変更する
                            RegistryEdit.SetRegistryValue(accountKey, ApplicationConst.REG_IMAPPASSWORD, encryptPassword, RegistryDataType.Binary);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 起動時の同期完了イベント
        /// </summary>
        private void SyncEndBootEvent()
        {
            for (int i = 0; i <= 10; i++)
            {
                Thread.Sleep(1000);
                Application.DoEvents();
            }
            try
            {
                prcOutLook.CloseMainWindow();
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// ID指定でOutLookのプロセスを終了する
        /// </summary>
        /// <param name="processId">プロセスID</param>
        private void ExitProcessOutLook(int processId)
        {
            SleepApplication(1);
            Process[] ps = System.Diagnostics.Process.GetProcesses();
            foreach (Process p in ps)
            {
                if (p.ProcessName == ApplicationConst.OUTLOOK)
                {
                    if (processId == 0)
                    {
                        p.Kill();
                        p.Close();
                        p.Dispose();
                    }
                    else
                    {
                        if (p.Id != processId)
                        {
                            p.Kill();
                            p.Close();
                            p.Dispose();
                        }
                    }
                }
            }
        }

        /// <summary>
        /// フォルダ指定のファイルを削除
        /// </summary>
        /// <param name="targetFolderPath"></param>
        private void DeletePstFiles(string targetFolderPath)
        {
            try
            {
                foreach (string f in Directory.GetFiles(targetFolderPath))
                {
                    System.IO.File.Delete(f);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// OutLookプロセスの存在チェック
        /// </summary>
        /// <returns></returns>
        private bool CheckOutLookProcess()
        {
            SleepApplication(1);
            Process[] ps = System.Diagnostics.Process.GetProcesses();
            foreach (Process p in ps)
            {
                if (p.ProcessName == ApplicationConst.OUTLOOK)
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// OutLookウィンドウを隠す
        /// </summary>
        /// <returns></returns>
        private void OutLookProcessHide()
        {
            SleepApplication(1);
            Process[] ps = System.Diagnostics.Process.GetProcesses();
            foreach (Process p in ps)
            {
                if (p.ProcessName == ApplicationConst.OUTLOOK)
                {
                    ShowWindow(p.MainWindowHandle, 11);
                    SetForegroundWindow(p.MainWindowHandle);
                }
            }
        }

        /// <summary>
        /// OutLookの最大化チェック
        /// </summary>
        /// <returns></returns>
        private bool OutLookMaximizeWindow()
        {
            SleepApplication(1);
            Process[] ps = System.Diagnostics.Process.GetProcesses();
            foreach (Process p in ps)
            {
                if (p.ProcessName == ApplicationConst.OUTLOOK)
                {
                    if (IsZoomed(p.MainWindowHandle))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// OutLookプロセスを最大化表示にする
        /// </summary>
        /// <returns></returns>
        private void OutLookProcessMaximize()
        {
            SleepApplication(1);
            Process[] ps = System.Diagnostics.Process.GetProcesses();
            foreach (Process p in ps)
            {
                if (p.ProcessName == ApplicationConst.OUTLOOK)
                {
                    ShowWindow(p.MainWindowHandle, 3);
                    SetForegroundWindow(p.MainWindowHandle);
                }
            }
        }

        /// <summary>
        /// メールエクスポートタブのテキストの入力値をチェックする
        /// </summary>
        /// <returns></returns>
        private bool CheckInputTextEmptyMailBoxExport()
        {
            if (string.IsNullOrEmpty(txtImapServerName.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_SERVERNAME), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtImapServerName.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtImapPassword.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PASSWORD), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtImapPassword.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtImapTargetFilePath.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_USERFILE), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtImapTargetFilePath.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtImapPstFilePath.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PSTFILEPATH), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtImapPstFilePath.Focus();
                return false;
            }
            return true;
        }

        /// <summary>
        /// メールインポートタブのテキストの入力値をチェックする
        /// </summary>
        /// <returns></returns>
        private bool CheckInputTextEmptyMailBoxImport()
        {
            if (string.IsNullOrEmpty(txtEx2013ServerName.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_FQDN), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2013ServerName.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtEx2013Domain.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_DOMAINNAME), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2013Domain.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtEx2013User.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_USERNAME), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2013User.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtEx2013Password.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PASSWORD), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2013Password.Focus();
                return false;
            }

            //if (string.IsNullOrEmpty(txtImapTargetFilePath.Text))
            //{
            //    MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_USERFILE), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
            //    txtImapTargetFilePath.Focus();
            //    return false;
            //}
            if (string.IsNullOrEmpty(txt2013PstFilePath.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PSTFILEPATH), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txt2013PstFilePath.Focus();
                return false;
            }
            return true;
        }

        /// <summary>
        /// メールエクスポートタブのテキストのファイルパスの存在チェックする
        /// </summary>
        /// <returns></returns>
        private bool CheckTextFilePathMailBoxExport()
        {
            if (!File.Exists(txtImapTargetFilePath.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_ERROR_INVALIDPATH, MessageConst.MSG_USERFILE), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtImapTargetFilePath.Focus();
                return false;
            }
            if (!Directory.Exists(txtImapPstFilePath.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_ERROR_INVALIDPATH, MessageConst.MSG_PSTFILEPATH), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtImapPstFilePath.Focus();
                return false;
            }
            return true;
        }

        /// <summary>
        /// メールインポートタブのテキストのファイルパスの存在チェックする
        /// </summary>
        /// <returns></returns>
        private bool CheckTextFilePathMailBoxImport()
        {
            if (!Check2013ExistPstFile(txt2013PstFilePath.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_ERROR_INVALIDPATH, MessageConst.MSG_PSTFILE), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txt2013PstFilePath.Focus();
                return false;
            }
            if (!Directory.Exists(txt2013PstFilePath.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_ERROR_INVALIDPATH, MessageConst.MSG_PSTFILEPATH), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txt2013PstFilePath.Focus();
                return false;
            }
            if (!clsMod.SearchString(txt2013PstFilePath.Text, txtEx2013ServerName.Text.Trim()))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_ERROR_INVALIDNETWORKPATH, MessageConst.MSG_PSTFILEPATH), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txt2013PstFilePath.Focus();
                return false;
            }
            return true;
        }

        /// <summary>
        /// パブリックフォルダエクスポートタブのテキストの入力値をチェックする
        /// </summary>
        /// <returns></returns>
        private bool CheckInputTextEmptyPublicFolderExport()
        {
            if (string.IsNullOrEmpty(txtEx2003ServerFullName.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_SERVERNAME), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2003ServerFullName.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtEx2003Domain.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_DOMAINNAME), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2003Domain.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtEx2003AdminUser.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_USERNAME), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2003AdminUser.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtEx2003AdminPassword.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PASSWORD), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtEx2003AdminPassword.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtPublicPstFilePath2003.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PSTFILEPATH), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtPublicPstFilePath2003.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtPublicFolder2003.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PUBLICFOLDER), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtPublicFolder2003.Focus();
                return false;
            }
            if (!CheckProfileName(ApplicationConst.PROFILE_NAME_2003))
            {
                MessageBox.Show(MessageConst.MSG_NOREGISTED_EX2003, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return false;
            }
            return true;
        }

        /// <summary>
        /// パブリックフォルダインポートのテキストの入力値をチェックする
        /// </summary>
        /// <returns></returns>
        private bool CheckInputTextEmptyPublicFolderImport()
        {
            if (string.IsNullOrEmpty(txtPublicPstFilePath2013.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PSTFILEPATH), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtPublicPstFilePath2013.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtPublicFolder2013.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_INPUT_TEXT, MessageConst.MSG_PUBLICFOLDER), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtPublicFolder2013.Focus();
                return false;
            }
            if (!CheckProfileName(ApplicationConst.PROFILE_NAME_2013))
            {
                MessageBox.Show(MessageConst.MSG_NOREGISTED_EX2013, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return false;
            }
            return true;
        }


        private bool CheckProfileName(string strTargetProfile)
        {
            bool bolRet = false;
            //レジストリからプロファイル配下を取得する
            string[] profiles = RegistryEdit.GetSubKeyNames(ApplicationConst.REG_KEY_PROFILE);
            foreach (string profile in profiles)
            {
                if (profile == strTargetProfile)
                {
                    bolRet = true;
                }
            }
            return bolRet;
        }

        /// <summary>
        /// パブリックフォルダエクスポートタブのテキストのファイルパスの存在チェックする
        /// </summary>
        /// <returns></returns>
        private bool CheckTextFilePathPublicFolderExport()
        {
            if (!Directory.Exists(txtPublicPstFilePath2003.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_ERROR_INVALIDPATH, MessageConst.MSG_PSTFILEPATH), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtPublicPstFilePath2003.Focus();
                return false;
            }
            return true;
        }

        /// <summary>
        /// パブリックフォルダインポートタブのテキストのファイルパスの存在チェックする
        /// </summary>
        /// <returns></returns>
        private bool CheckTextFilePathPublicFolderImport()
        {
            if (!File.Exists(txtPublicPstFilePath2013.Text))
            {
                MessageBox.Show(string.Format(MessageConst.MSG_ERROR_INVALIDPATH, MessageConst.MSG_PSTFILE), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                txtPublicPstFilePath2013.Focus();
                return false;
            }
            return true;
        }

        /// <summary>
        /// 指定フォルダの権限をチェックする
        /// </summary>
        /// <param name="strPath"></param>
        /// <returns></returns>
        private bool CheckSecurityAndAccessRule(string strPath)
        {
            DirectorySecurity sec = Directory.GetAccessControl(strPath);
            AuthorizationRuleCollection rules = sec.GetAccessRules(true, true, typeof(NTAccount));
            for (int i = 0; i < rules.Count; i++)
            {
                FileSystemAccessRule fsar = (FileSystemAccessRule)rules[i];
                if (fsar.AccessControlType == AccessControlType.Allow)
                {
                    if ((fsar.IdentityReference as NTAccount).Value == ApplicationConst.EDIT_EVERYONE)
                    {
                        if (fsar.FileSystemRights.ToString() == ApplicationConst.FULL_CONTROL)
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// PSTファイルの存在チェック
        /// </summary>
        /// <param name="pstFolder"></param>
        /// <returns></returns>
        private bool Check2013ExistPstFile(string pstFolder)
        {
            int intCount = 0;
            foreach (string strFilePath in Directory.GetFiles(pstFolder, "*.pst"))
            {
                intCount++;
            }
            if (intCount == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        /// <summary>
        /// Exchange2013ユーザーのメールボックスの存在チェックをする
        /// </summary>
        /// <param name="userList"></param>
        /// <param name="strServerName"></param>
        /// <param name="strDomain"></param>
        /// <param name="strAdmin"></param>
        /// <returns></returns>
        private bool Check2013UserMailBox(List<string[]> userList, ExchangeServer2013Information Info2013)
        {
            bool bolRet = true;
            PSSession sesEx2013 = null;

            RunspaceConfiguration rsconf = RunspaceConfiguration.Create();
            RunspaceConfigurationEntryCollection<ScriptConfigurationEntry> scripts = rsconf.Scripts;

            foreach (string stFilePath in Directory.GetFiles(Path.Combine(GetAppPath(), ShellCommandConst.PATH_SHELLCOMMAND), "*.ps1"))
            {
                //関数名はファイル名
                string scriptName = Path.GetFileNameWithoutExtension(stFilePath);
                string strScript = string.Empty;
                using (StreamReader sr = new StreamReader(stFilePath))
                {
                    strScript = sr.ReadToEnd();
                }
                //スクリプトを登録
                scripts.Append(new ScriptConfigurationEntry(scriptName, strScript));
            }

            try
            {
                //Runspaceにスクリプトを登録して作成する
                using (Runspace rs = RunspaceFactory.CreateRunspace(rsconf))
                {
                    //Runspaceをオープン
                    rs.Open();
                    using (PowerShell ps = PowerShell.Create())
                    {
                        //セッションの生成
                        PSCommand sessCreate = new PSCommand();
                        sessCreate.AddCommand(ShellCommandConst.COMMAND_CREATE);
                        sessCreate.AddParameter(ShellCommandConst.PARAM_HOST, string.Format(ApplicationConst.URL_POWERSHELL, Info2013.ServerName));
                        sessCreate.AddParameter(ShellCommandConst.PARAM_USER, string.Format(ApplicationConst.DOMAIN_FORMAT, Info2013.DomainName, Info2013.UserName));
                        sessCreate.AddParameter(ShellCommandConst.PARAM_PASSWORD, Info2013.UserPassword);
                        ps.Commands = sessCreate;
                        ps.Runspace = rs;
                        Collection<PSObject> resultCreate = ps.Invoke();
                        sesEx2013 = (PSSession)resultCreate[0].BaseObject;

                        PSCommand sessDelete = new PSCommand();

                        //ユーザーの数をループ処理
                        int SessionLimit = 0;
                        for (int i = 1; i <= userList.Count; i++)
                        {
                            //セッションタイムアウトが発生するので20件程度でセッションを再度作成する
                            if (SessionLimit == TIMEOUT_LIMIT)
                            {
                                //前のセッションの削除
                                sessDelete.AddCommand(ShellCommandConst.COMMAND_DELETE);
                                sessDelete.AddParameter(ShellCommandConst.PARAM_SESSION, sesEx2013);
                                ps.Commands = sessDelete;
                                ps.Runspace = rs;
                                ps.Invoke();

                                Thread.Sleep(TIME_CHECK);

                                //セッションの再生成
                                sessCreate = new PSCommand();
                                sessCreate.AddCommand(ShellCommandConst.COMMAND_CREATE);
                                sessCreate.AddParameter(ShellCommandConst.PARAM_HOST, string.Format(ApplicationConst.URL_POWERSHELL, Info2013.ServerName));
                                sessCreate.AddParameter(ShellCommandConst.PARAM_USER, string.Format(ApplicationConst.DOMAIN_FORMAT, Info2013.DomainName, Info2013.UserName));
                                sessCreate.AddParameter(ShellCommandConst.PARAM_PASSWORD, Info2013.UserPassword);
                                ps.Commands = sessCreate;
                                ps.Runspace = rs;
                                resultCreate = ps.Invoke();
                                sesEx2013 = (PSSession)resultCreate[0].BaseObject;

                                SessionLimit = 0;
                            }
                            else
                            {
                                SessionLimit++;
                            }

                            if (sesEx2013 != null)
                            {
                                string strUserName = userList[i - 1][0];
                                PSCommand sessCheck = new PSCommand();
                                sessCheck.AddCommand(ShellCommandConst.COMMAND_CHECK);
                                sessCheck.AddParameter(ShellCommandConst.PARAM_SESSION, sesEx2013);
                                sessCheck.AddParameter(ShellCommandConst.PARAM_NAME, strUserName);
                                ps.Commands = sessCheck;
                                ps.Runspace = rs;
                                Collection<PSObject> resultCheck = ps.Invoke();
                                if (resultCheck.Count != 2)
                                {
                                    bolRet = false;
                                    clsMod.WriteLog(txt2013Log, strUserName + LogConst.LOG_NO_EXIST);
                                    FileLogTrace.WriteErrorLog(string.Format(LogConst.LOG_ALIAS, strUserName, MessageConst.MSG_MAILBOX, MessageConst.MSG_NOUSER));
                                    break;
                                }
                                if (resultCheck[1].ToString() != strUserName)
                                {
                                    bolRet = false;
                                    clsMod.WriteLog(txt2013Log, strUserName + LogConst.LOG_NO_EXIST);
                                    FileLogTrace.WriteErrorLog(string.Format(LogConst.LOG_ALIAS, strUserName, MessageConst.MSG_MAILBOX, MessageConst.MSG_NOUSER));
                                    break;
                                }
                                clsMod.WriteLog(txt2013Log, strUserName + LogConst.LOG_OK);
                            }

                        }

                        if (sesEx2013 != null)
                        {
                            //セッションの削除
                            sessDelete.AddCommand(ShellCommandConst.COMMAND_DELETE);
                            sessDelete.AddParameter(ShellCommandConst.PARAM_SESSION, sesEx2013);
                            ps.Commands = sessDelete;
                            ps.Runspace = rs;
                            ps.Invoke();
                        }
                    }
                }
                return bolRet;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// ExchangeManagementShellでコマンド実行
        /// </summary>
        /// <param name="userList"></param>
        /// <param name="strServerName"></param>
        /// <param name="strDomain"></param>
        /// <param name="strAdmin"></param>
        /// <param name="strFolder"></param>
        public void ExecuteRemoteShell(List<string[]> userList, ExchangeServer2013Information Info2013, string strFolder)
        {
            try
            {
                //セッション確立のための初期化
                PSSession sesEx2013 = null;
                RunspaceConfiguration rsconf = RunspaceConfiguration.Create();
                RunspaceConfigurationEntryCollection<ScriptConfigurationEntry> scripts = rsconf.Scripts;
                //指定フォルダ内のps1ファイルを全取得しループ
                foreach (string stFilePath in Directory.GetFiles(Path.Combine(GetAppPath(), ShellCommandConst.PATH_SHELLCOMMAND), "*.ps1"))
                {
                    //関数名はファイル名
                    string scriptName = Path.GetFileNameWithoutExtension(stFilePath);
                    string strScript = string.Empty;
                    using (StreamReader sr = new StreamReader(stFilePath))
                    {
                        strScript = sr.ReadToEnd();
                    }
                    //スクリプトを登録
                    scripts.Append(new ScriptConfigurationEntry(scriptName, strScript));
                }
                //Runspaceにスクリプトを登録して作成する
                using (Runspace rs = RunspaceFactory.CreateRunspace(rsconf))
                {
                    //Runspaceをオープン
                    rs.Open();
                    using (PowerShell ps = PowerShell.Create())
                    {
                        //セッションの生成
                        PSCommand sessCreate = new PSCommand();
                        sessCreate.AddCommand(ShellCommandConst.COMMAND_CREATE);
                        sessCreate.AddParameter(ShellCommandConst.PARAM_HOST, string.Format(ApplicationConst.URL_POWERSHELL, Info2013.ServerName));
                        sessCreate.AddParameter(ShellCommandConst.PARAM_USER, string.Format(ApplicationConst.DOMAIN_FORMAT, Info2013.DomainName, Info2013.UserName));
                        sessCreate.AddParameter(ShellCommandConst.PARAM_PASSWORD, Info2013.UserPassword);
                        ps.Commands = sessCreate;
                        ps.Runspace = rs;
                        Collection<PSObject> resultCreate = ps.Invoke();
                        sesEx2013 = (PSSession)resultCreate[0].BaseObject;

                        PSCommand sessDelete = new PSCommand();

                        //ユーザーの数をループ処理
                        int SessionLimit = 0;
                        for (int i = 1; i <= userList.Count; i++)
                        {
                            //セッションタイムアウトが発生するので20件程度でセッションを再度作成する
                            if (SessionLimit == TIMEOUT_LIMIT)
                            {
                                //前のセッションの削除
                                sessDelete.AddCommand(ShellCommandConst.COMMAND_DELETE);
                                sessDelete.AddParameter(ShellCommandConst.PARAM_SESSION, sesEx2013);
                                ps.Commands = sessDelete;
                                ps.Runspace = rs;
                                ps.Invoke();

                                Thread.Sleep(TIME_CHECK);

                                //セッションの再生成
                                sessCreate = new PSCommand();
                                sessCreate.AddCommand(ShellCommandConst.COMMAND_CREATE);
                                sessCreate.AddParameter(ShellCommandConst.PARAM_HOST, string.Format(ApplicationConst.URL_POWERSHELL, Info2013.ServerName));
                                sessCreate.AddParameter(ShellCommandConst.PARAM_USER, string.Format(ApplicationConst.DOMAIN_FORMAT, Info2013.DomainName, Info2013.UserName));
                                sessCreate.AddParameter(ShellCommandConst.PARAM_PASSWORD, Info2013.UserPassword);
                                ps.Commands = sessCreate;
                                ps.Runspace = rs;
                                resultCreate = ps.Invoke();
                                sesEx2013 = (PSSession)resultCreate[0].BaseObject;

                                SessionLimit = 0;
                            }
                            else
                            {
                                SessionLimit++;
                            }

                            //セッションが確立できた場合のみ処理
                            if (sesEx2013 != null)
                            {
                                //ユーザー名を取得
                                string strUserName = userList[i - 1][0];
                                clsMod.WriteLog(txt2013Log, strUserName);
                                //PSTファイルのパスを生成
                                string pstFilePath = string.Format(ApplicationConst.PATH_PSTFILE, strFolder, strUserName);
                                //NewMailBoxImportRequestを実行
                                PSCommand sessImport = new PSCommand();
                                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_IMPORT, strUserName, LogConst.LOG_START2));
                                sessImport.AddCommand(ShellCommandConst.COMMAND_IMPORT);
                                sessImport.AddParameter(ShellCommandConst.PARAM_SESSION, sesEx2013);
                                sessImport.AddParameter(ShellCommandConst.PARAM_MAILBOX, strUserName);
                                sessImport.AddParameter(ShellCommandConst.PARAM_PSTFILE, pstFilePath);
                                sessImport.AddParameter(ShellCommandConst.PARAM_NAME, strUserName);
                                ps.Commands = sessImport;
                                ps.Runspace = rs;
                                ps.Invoke();
                                bool bolNext = false;
                                //終わるまで待機
                                while (!bolNext)
                                {
                                    SleepApplication(60);
                                    //GetMailBoxImportRequestを実行()
                                    PSCommand sessCompleted = new PSCommand();
                                    clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_IMPORT, strUserName, LogConst.LOG_INPROGRESS2));
                                    sessCompleted.AddCommand(ShellCommandConst.COMMAND_GETSTATUS);
                                    sessCompleted.AddParameter(ShellCommandConst.PARAM_NAME, strUserName);
                                    sessCompleted.AddParameter(ShellCommandConst.PARAM_STATUS, ShellCommandConst.STATUS_COMLETE);
                                    ps.Commands = sessCompleted;
                                    ps.Runspace = rs;
                                    Collection<PSObject> resultCompleted = ps.Invoke();
                                    if (resultCompleted.Count == 0)
                                    {
                                        PSCommand sessFailed = new PSCommand();
                                        sessFailed.AddCommand(ShellCommandConst.COMMAND_GETSTATUS);
                                        sessFailed.AddParameter(ShellCommandConst.PARAM_NAME, strUserName);
                                        sessFailed.AddParameter(ShellCommandConst.PARAM_STATUS, ShellCommandConst.STATUS_FAILD);
                                        ps.Commands = sessFailed;
                                        ps.Runspace = rs;
                                        Collection<PSObject> resultFailed = ps.Invoke();
                                        if (resultFailed.Count != 0)
                                        {
                                            //MessageBox.Show("インポートに失敗しました");
                                            PSCommand sessRemove = new PSCommand();
                                            sessRemove.AddCommand(ShellCommandConst.COMMAND_REMOVE);
                                            sessRemove.AddParameter(ShellCommandConst.PARAM_NAME, strUserName);
                                            ps.Commands = sessRemove;
                                            ps.Runspace = rs;
                                            ps.Invoke();
                                            clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_IMPORT, strUserName, LogConst.LOG_FAILD));
                                            FileLogTrace.WriteErrorLog(string.Format(LogConst.LOG_ALIAS, strUserName, MessageConst.MSG_STATUS, MessageConst.MSG_ERROR_IMPORT));
                                            bolNext = true;
                                            bolMigrationMailBoxImport = false;
                                            FileLogTrace.WriteResultLog(string.Format(LogConst.LOG_RESULT_FAILED, strUserName, LogConst.LOG_RESULT_IMPORT),i);
                                        }
                                        else
                                        {
                                            PSCommand sessNone = new PSCommand();
                                            sessNone.AddCommand(ShellCommandConst.COMMAND_GETSTATUS);
                                            sessNone.AddParameter(ShellCommandConst.PARAM_NAME, strUserName);
                                            sessNone.AddParameter(ShellCommandConst.PARAM_STATUS, ShellCommandConst.STATUS_NONE);
                                            ps.Commands = sessNone;
                                            ps.Runspace = rs;
                                            Collection<PSObject> resultNone = ps.Invoke();
                                            if (resultNone.Count == 0)
                                            {
                                                //MessageBox.Show("インポートに失敗しました");
                                                PSCommand sessRemove = new PSCommand();
                                                sessRemove.AddCommand(ShellCommandConst.COMMAND_REMOVE);
                                                sessRemove.AddParameter(ShellCommandConst.PARAM_NAME, strUserName);
                                                ps.Commands = sessRemove;
                                                ps.Runspace = rs;
                                                ps.Invoke();
                                                clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_IMPORT, strUserName, LogConst.LOG_FAILD));
                                                FileLogTrace.WriteErrorLog(string.Format(LogConst.LOG_ALIAS, strUserName, MessageConst.MSG_STATUS, MessageConst.MSG_ERROR_IMPORT));
                                                bolNext = true;
                                                bolMigrationMailBoxImport = false;
                                                FileLogTrace.WriteResultLog(string.Format(LogConst.LOG_RESULT_FAILED, strUserName, LogConst.LOG_RESULT_IMPORT),i);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        //RemoveMailboxImportRequestを実行
                                        PSCommand sessRemove = new PSCommand();
                                        sessRemove.AddCommand(ShellCommandConst.COMMAND_REMOVE);
                                        sessRemove.AddParameter(ShellCommandConst.PARAM_NAME, strUserName);
                                        ps.Commands = sessRemove;
                                        ps.Runspace = rs;
                                        ps.Invoke();
                                        clsMod.WriteLog(txt2013Log, string.Format(LogConst.LOG_IMPORT, strUserName, LogConst.LOG_SUCCESS));
                                        bolNext = true;
                                        FileLogTrace.WriteResultLog(string.Format(LogConst.LOG_RESULT_SUCCESS, strUserName, LogConst.LOG_RESULT_IMPORT),i);
                                    }
                                }
                            }
                        }

                        //セッションが確立できた場合のみ処理
                        if (sesEx2013 != null)
                        {
                            //セッションの削除
                            sessDelete.AddCommand(ShellCommandConst.COMMAND_DELETE);
                            sessDelete.AddParameter(ShellCommandConst.PARAM_SESSION, sesEx2013);
                            ps.Commands = sessDelete;
                            ps.Runspace = rs;
                            ps.Invoke();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Exchange2003サーバーへの資格情報の登録
        /// </summary>
        /// <param name="strServerName">サーバー名かまたはIPアドレス</param>
        /// <param name="strServerName">ドメイン</param>
        /// <param name="strServerName">システム管理者ユーザー名</param>
        private void CreateCredentialInfo(string strServerName, string strDomain, string strAdminName)
        {
            try
            {
                RunspaceConfiguration rsconf = RunspaceConfiguration.Create();
                RunspaceConfigurationEntryCollection<ScriptConfigurationEntry> scripts = rsconf.Scripts;

                //関数名はファイル名とする
                string stFilePath = System.IO.Path.Combine(Path.Combine(GetAppPath(), ShellCommandConst.PATH_SHELLCOMMAND), ShellCommandConst.PS1_CREATE_CRED);
                string scriptName = Path.GetFileNameWithoutExtension(stFilePath);
                string strScript = string.Empty;
                string strScriptName = Path.GetFileNameWithoutExtension(stFilePath);
                using (StreamReader sr = new StreamReader(stFilePath))
                {
                    strScript = sr.ReadToEnd();
                }
                //スクリプトを登録
                scripts.Append(new ScriptConfigurationEntry(scriptName, strScript));
                //Runspaceにスクリプトを登録して作成する
                using (Runspace rs = RunspaceFactory.CreateRunspace(rsconf))
                {
                    //Runspaceをオープンする(スクリプトを登録した状態)
                    rs.Open();
                    using (PowerShell ps = PowerShell.Create())
                    {
                        PSCommand importCred_sess = new PSCommand();
                        importCred_sess.AddCommand(strScriptName);
                        importCred_sess.AddParameter(ShellCommandConst.PARAM_HOST, strServerName);
                        importCred_sess.AddParameter(ShellCommandConst.PARAM_USER, string.Format(ApplicationConst.DOMAIN_FORMAT, strDomain, strAdminName));
                        importCred_sess.AddParameter(ShellCommandConst.PARAM_PASSWORD, txtEx2003AdminPassword.Text.Trim());
                        ps.Commands = importCred_sess;
                        ps.Runspace = rs;
                        ps.Invoke();
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Exchange2013情報が正しく入力されているかをチェック
        /// </summary>
        /// <param name="userList"></param>
        /// <param name="Info2013"></param>
        /// <returns></returns>
        private bool Check2013Information(ExchangeServer2013Information Info2013)
        {
            bool bolRet = true;
            PSSession sesEx2013 = null;

            RunspaceConfiguration rsconf = RunspaceConfiguration.Create();
            RunspaceConfigurationEntryCollection<ScriptConfigurationEntry> scripts = rsconf.Scripts;

            foreach (string stFilePath in Directory.GetFiles(Path.Combine(GetAppPath(), ShellCommandConst.PATH_SHELLCOMMAND), "*.ps1"))
            {
                //関数名はファイル名
                string scriptName = Path.GetFileNameWithoutExtension(stFilePath);
                string strScript = string.Empty;
                using (StreamReader sr = new StreamReader(stFilePath))
                {
                    strScript = sr.ReadToEnd();
                }
                //スクリプトを登録
                scripts.Append(new ScriptConfigurationEntry(scriptName, strScript));
            }

            try
            {
                //Runspaceにスクリプトを登録して作成する
                using (Runspace rs = RunspaceFactory.CreateRunspace(rsconf))
                {
                    //Runspaceをオープン
                    rs.Open();
                    using (PowerShell ps = PowerShell.Create())
                    {
                        //セッションの生成
                        PSCommand sessCreate = new PSCommand();
                        sessCreate.AddCommand(ShellCommandConst.COMMAND_CREATE);
                        sessCreate.AddParameter(ShellCommandConst.PARAM_HOST, string.Format(ApplicationConst.URL_POWERSHELL, Info2013.ServerName));
                        sessCreate.AddParameter(ShellCommandConst.PARAM_USER, string.Format(ApplicationConst.DOMAIN_FORMAT, Info2013.DomainName, Info2013.UserName));
                        sessCreate.AddParameter(ShellCommandConst.PARAM_PASSWORD, Info2013.UserPassword);
                        ps.Commands = sessCreate;
                        ps.Runspace = rs;
                        Collection<PSObject> resultCreate = ps.Invoke();
                        sesEx2013 = (PSSession)resultCreate[0].BaseObject;

                        if (sesEx2013 != null)
                        {
                            //セッションの削除
                            PSCommand sessDelete = new PSCommand();
                            sessDelete.AddCommand(ShellCommandConst.COMMAND_DELETE);
                            sessDelete.AddParameter(ShellCommandConst.PARAM_SESSION, sesEx2013);
                            ps.Commands = sessDelete;
                            ps.Runspace = rs;
                            ps.Invoke();
                        }
                        else
                        {
                            bolRet = false;
                        }
                    }
                }
            }
            catch
            {
                bolRet = false;
            }
            return bolRet;
        }
        
        /// <summary>
        /// 自動生成されるPSTファイルサイズが膨張中であるかをチェック
        /// </summary>
        /// <param name="userList"></param>
        /// <param name="profileName"></param>
        /// <returns></returns>
        private bool CheckPstFileSize(List<string[]> userList,string profileName,int time)
        {
            bool bolRet = true;
            long[] PstFileSize = null;
            PstFileSize = new long[userList.Count];
            long[] PstFileSizeTemp = null;
            PstFileSizeTemp = new long[userList.Count];
            for (int i = 1; i <= userList.Count; i++)
            {
                string strFilePath = string.Format(ApplicationConst.OUTLOOK_DEFAULT_PATH, Environment.UserName.ToString(), Environment.UserDomainName.ToString(), userList[i - 1][1], profileName);
                if (File.Exists(strFilePath))
                {
                    FileInfo f = new FileInfo(strFilePath);
                    PstFileSize[i - 1] = f.Length;
                }
            }
            //各PSTファイルの膨張を確認する
            for (int i = 1; i <= time; i++)
            {
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_INPROGRESS, "PSTファイルサイズ確認"));
                SleepApplication(1);
                Application.DoEvents();
                for (int j = 1; j <= userList.Count; j++)
                {
                    string strFilePath = string.Format(ApplicationConst.OUTLOOK_DEFAULT_PATH, Environment.UserName.ToString(), Environment.UserDomainName.ToString(), userList[j - 1][1], profileName);
                    if (File.Exists(strFilePath))
                    {
                        FileInfo f = new FileInfo(strFilePath);
                        PstFileSizeTemp[j - 1] = f.Length;
                    }
                }
                for (int j = 1; j <= userList.Count; j++)
                {
                    if (PstFileSize[j - 1] != PstFileSizeTemp[j - 1])
                    {
                        return false;
                    }
                }
            }
            return bolRet;
        }

        /// <summary>
        /// 自動生成されるPSTファイルサイズが膨張中であるかをチェック
        /// </summary>
        /// <param name="userList"></param>
        /// <param name="profileName"></param>
        /// <returns></returns>
        private bool CheckPstFileSize(string UserName, string profileName, int time)
        {
            bool bolRet = true;
            long PstFileSize = 0;
            long PstFileSizeTemp = 0;
            string strFilePath = string.Format(ApplicationConst.OUTLOOK_DEFAULT_PATH, Environment.UserName.ToString(), Environment.UserDomainName.ToString(), UserName, profileName);
            if (File.Exists(strFilePath))
            {
                FileInfo f = new FileInfo(strFilePath);
                PstFileSize = f.Length;
            }

            //各PSTファイルの膨張を確認する
            for (int i = 1; i <= time; i++)
            {
                clsMod.WriteLog(txtImapLog, string.Format(LogConst.LOG_INPROGRESS, "PSTファイルサイズ確認"));
                Thread.Sleep(TIME_CHECK);
                Application.DoEvents();
                strFilePath = string.Format(ApplicationConst.OUTLOOK_DEFAULT_PATH, Environment.UserName.ToString(), Environment.UserDomainName.ToString(), UserName, profileName);
                if (File.Exists(strFilePath))
                {
                    FileInfo f = new FileInfo(strFilePath);
                    PstFileSizeTemp = f.Length;
                }
                if (PstFileSize != PstFileSizeTemp)
                {
                    return false;
                }
            }
            return bolRet;
        }

        /// <summary>
        /// スリープ処理
        /// </summary>
        /// <param name="time">設定秒数</param>
        private void SleepApplication(int time)
        {
            for (int i = 1; i <= time * 2; i++)
            {
                Thread.Sleep(TIME_CHECK);
                Application.DoEvents();
            }
        }

        /// <summary>
        /// オプション画面の設定値を取得する
        /// </summary>
        private void GetOptionFormValue()
        {
            //オプション画面設定
            DownloadTime = int.Parse(Properties.Settings.Default.Option_DownloadTimer);
            ExportTime = int.Parse(Properties.Settings.Default.Option_ExportTimer);
            AccountCount = int.Parse(Properties.Settings.Default.Option_Account);
            OutLookTime = int.Parse(Properties.Settings.Default.Option_OutLookTimer);
        }
        #endregion

        #region IMAPへのアクセス
        /// <summary>
        /// IMAPサーバーへのログインチェック
        /// </summary>
        /// <param name="hostName"></param>
        /// <param name="portNumber"></param>
        /// <param name="userName"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        private bool ConnectImapServer(string hostName, decimal portNumber, string userName, string password)
        {
            string response = string.Empty;
            //IMAPサーバーに接続する
            using (TcpClient tcp = new TcpClient())
            {
                tcp.Connect(hostName, int.Parse(portNumber.ToString()));

                if (tcp.Connected)
                {
                    using (NetworkStream stream = tcp.GetStream())
                    {
                        //ログインする
                        stream.ReadTimeout = 10;
                        WriteNetworkStream(stream, string.Format(ApplicationConst.IMAP_COMMAND_LOGIN2));
                        WriteNetworkStream(stream, string.Format(ApplicationConst.IMAP_COMMAND_LOGIN, userName, password));
                        response = ReadNetworkStream(stream);
                        //ログアウトする
                        WriteNetworkStream(stream, ApplicationConst.IMAP_COMMAND_LOGOUT);
                    }
                }
            }
            if (clsMod.SearchString(response, ApplicationConst.OK_LOGIN))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// ストリームを読み込む
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        private string ReadNetworkStream(NetworkStream stream)
        {
            string message = string.Empty;

            if (stream.CanRead)
            {
                byte[] readBuffer = new byte[1024];
                StringBuilder readMessage = new StringBuilder();
                int numberOfBytesRead = 0;

                do
                {
                    try
                    {
                        numberOfBytesRead = stream.Read(readBuffer, 0, readBuffer.Length);

                        if (numberOfBytesRead > 0)
                        {
                            readMessage.AppendLine(Encoding.ASCII.GetString(readBuffer, 0, numberOfBytesRead));
                        }
                    }
                    catch (System.IO.IOException)
                    {
                        break;
                    }
                }
                while (numberOfBytesRead > 0);
                message = readMessage.ToString();
            }

            return message;
        }

        /// <summary>
        /// ストリームを書き出す
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="contents"></param>
        private void WriteNetworkStream(NetworkStream stream, string contents)
        {
            if (stream.CanWrite)
            {
                byte[] writeBuffer = Encoding.ASCII.GetBytes(contents);
                stream.Write(writeBuffer, 0, writeBuffer.Length);
                stream.Flush();
            }
        }
        #endregion
    }

}
